home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
FishMarket 1.0
/
FishMarket v1.0.iso
/
fishies
/
326-350
/
disk_350
/
memmometer
/
mminit.c
< prev
next >
Wrap
C/C++ Source or Header
|
1992-05-06
|
24KB
|
723 lines
/* : ai=0 bk=0 ts=8 */
#include "mm.h"
#define PROJMAX 3 /* number of project menu items */
#define SETUPMAX 2 /* number of setup menu items */
#define MODEMAX 2
#define FREQMAX 4 /* number of frequency menu items */
#define PRIOMAX 16 /* number of priority menu items */
#define CHIPMAX 5 /* number of chip mem size menu items */
#define CHIPAMAX 4 /* number of chip mem base addr menu items */
#define SFMAX 4 /* number of sf mem size menu items */
#define SFAMAX 4 /* number of sf mem base addr menu items */
#define FASTMAX 7 /* number of fast mem size menu items */
#define FASTAMAX 8 /* number of fast mem base addr menu items */
#define MAXMENU 9 /* total number of top level menus */
extern BOOL p_mode; /* preset frags mode = 0, warps mode = 1 */
extern long p_rate; /* preset sample interval, secs see menu */
extern long p_priority; /* preset priority, range -100 to +100 */
extern long p_chip; /* preset chip mem size, kbytes see menu */
extern long p_chipa; /* preset chip mem address, kb see menu */
extern long p_sf; /* preset slowfast mem size, kb see menu */
extern long p_sfa; /* preset slowfast mem addr, kb see menu */
extern long p_fast; /* preset fast mem size, mbytes see menu */
extern long p_fasta; /* preset fast mem addr, mbytes see menu */
/******************************************************/
/* Structure declarations for the menu sections */
/******************************************************/
struct MenuItem ProjItem[PROJMAX];
struct IntuiText ProjText[PROJMAX];
struct MenuItem SetupItem[SETUPMAX];
struct IntuiText SetupText[SETUPMAX];
struct MenuItem ModeItem[MODEMAX];
struct IntuiText ModeText[MODEMAX];
struct MenuItem FreqItem[FREQMAX];
struct IntuiText FreqText[FREQMAX];
struct MenuItem PrioItem[PRIOMAX];
struct IntuiText PrioText[PRIOMAX];
struct MenuItem ChipItem[CHIPMAX];
struct IntuiText ChipText[CHIPMAX];
struct MenuItem ChipAItem[CHIPAMAX];
struct IntuiText ChipAText[CHIPAMAX];
struct MenuItem SFItem[SFMAX];
struct IntuiText SFText[SFMAX];
struct MenuItem SFAItem[SFAMAX];
struct IntuiText SFAText[SFAMAX];
struct MenuItem FastItem[FASTMAX];
struct IntuiText FastText[FASTMAX];
struct MenuItem FastAItem[FASTAMAX];
struct IntuiText FastAText[FASTAMAX];
struct Menu menu[MAXMENU];
/*****************************************************************/
/* The following function initializes the structure arrays */
/* needed to provide the Project menu topic. */
/* this was left retro-compatible with Manx 3.4a (nplus1) */
/*****************************************************************/
void InitProjItems()
{
int n,nplus1;
/* initialize each menu item and IntuiText with loop */
for( n=0; n<PROJMAX; n++ )
{
nplus1 = n + 1;
ProjItem[n].NextItem = &ProjItem[nplus1];
ProjItem[n].LeftEdge = 0;
ProjItem[n].TopEdge = 9 * n;
ProjItem[n].Width = 64;
ProjItem[n].Height = 9;
ProjItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP;
ProjItem[n].MutualExclude = 0;
ProjItem[n].ItemFill = (APTR)&ProjText[n];
ProjItem[n].SelectFill = NULL;
ProjItem[n].Command = 0;
ProjItem[n].SubItem = NULL;
ProjItem[n].NextSelect = 0;
ProjText[n].FrontPen = BLUP;
ProjText[n].BackPen = WHTP;
ProjText[n].DrawMode = JAM2;/* render in fore and background */
ProjText[n].LeftEdge = 0;
ProjText[n].TopEdge = 1;
ProjText[n].ITextFont = NULL;
ProjText[n].NextText = NULL;
}
ProjItem[PROJMAX-1].NextItem = NULL;
/* initialize text for specific menu items */
ProjText[0].IText = (UBYTE *)"Front";
ProjText[1].IText = (UBYTE *)"Back";
ProjText[2].IText = (UBYTE *)"Quit";
}
/*****************************************************************/
/* The following initializes the structure arrays */
/* needed to provide the Setup menu topic. */
/*****************************************************************/
void InitSetupItems()
{
int n,nplus1;
/* initialize each menu item and IntuiText with loop */
for( n=0; n<SETUPMAX; n++ )
{
nplus1 = n + 1;
SetupItem[n].NextItem = &SetupItem[nplus1];
SetupItem[n].LeftEdge = 0;
SetupItem[n].TopEdge = 9 * n;
SetupItem[n].Width = 44;
SetupItem[n].Height = 9;
SetupItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP ;
SetupItem[n].MutualExclude = 0;
SetupItem[n].ItemFill = (APTR)&SetupText[n];
SetupItem[n].SelectFill = NULL;
SetupItem[n].Command = 0;
SetupItem[n].NextSelect = 0;
SetupText[n].FrontPen = BLUP;
SetupText[n].BackPen = WHTP;
SetupText[n].DrawMode = JAM2;
SetupText[n].LeftEdge = 0;
SetupText[n].TopEdge = 1;
SetupText[n].ITextFont = NULL;
SetupText[n].NextText = NULL;
}
SetupItem[SETUPMAX-1].NextItem = NULL;
SetupText[0].IText = (UBYTE *)"Mode";
SetupItem[0].SubItem = ModeItem;
SetupText[1].IText = (UBYTE *)"Freq";
SetupItem[1].SubItem = FreqItem;
/*****************************************************************/
/* The following initializes the structure arrays */
/* needed to provide the Mode submenu topic. */
/*****************************************************************/
for( n=0; n<MODEMAX; n++ )
{
nplus1 = n + 1;
ModeItem[n].NextItem = &ModeItem[nplus1];
ModeItem[n].LeftEdge = 38;
ModeItem[n].TopEdge = 9 * n;
ModeItem[n].Width = 72;
ModeItem[n].Height = 9;
ModeItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
ModeItem[n].MutualExclude = (~(1 << n));
ModeItem[n].ItemFill = (APTR)&ModeText[n];
ModeItem[n].SelectFill = NULL;
ModeItem[n].Command = 0;
ModeItem[n].SubItem = NULL;
ModeItem[n].NextSelect = 0;
ModeText[n].FrontPen = BLUP;
ModeText[n].BackPen = WHTP;
ModeText[n].DrawMode = JAM2; /* render in fore and background */
ModeText[n].LeftEdge = 0;
ModeText[n].TopEdge = 1;
ModeText[n].ITextFont = NULL;
ModeText[n].NextText = NULL;
}
ModeItem[MODEMAX-1].NextItem = NULL;
/* select mode subitem checked */
switch (p_mode) {
case 0: n = 0; break;
case 1: n = 1; break;
default: n = 1; p_mode = FALSE;
}
ModeItem[n].Flags |= CHECKED;
/* initialize text for specific submenu items */
ModeText[0].IText = (UBYTE *)" Frags";
ModeText[1].IText = (UBYTE *)" Warps";
/*****************************************************************/
/* The following initializes the structure arrays */
/* needed to provide the Freq submenu topic. */
/*****************************************************************/
for( n=0; n<FREQMAX; n++ )
{
nplus1 = n + 1;
FreqItem[n].NextItem = &FreqItem[nplus1];
FreqItem[n].LeftEdge = 38;
FreqItem[n].TopEdge = 9 * n;
FreqItem[n].Width = 88;
FreqItem[n].Height = 9;
FreqItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
FreqItem[n].MutualExclude = (~(1 << n));
FreqItem[n].ItemFill = (APTR)&FreqText[n];
FreqItem[n].SelectFill = NULL;
FreqItem[n].Command = 0;
FreqItem[n].SubItem = NULL;
FreqItem[n].NextSelect = 0;
FreqText[n].FrontPen = BLUP;
FreqText[n].BackPen = WHTP;
FreqText[n].DrawMode = JAM2; /* render in fore and background */
FreqText[n].LeftEdge = 0;
FreqText[n].TopEdge = 1;
FreqText[n].ITextFont = NULL;
FreqText[n].NextText = NULL;
}
FreqItem[FREQMAX-1].NextItem = NULL;
/* select frequency item checked */
switch (p_rate) {
case 1: n = 0; break;
case 2: n = 1; break;
case 5: n = 2; break;
case 10: n = 3; break;
default: n = 1; p_rate = 2;
}
FreqItem[n].Flags |= CHECKED;
/* initialize text for specific menu items */
FreqText[0].IText = (UBYTE *)" 1 Sec ";
FreqText[1].IText = (UBYTE *)" 2 Secs";
FreqText[2].IText = (UBYTE *)" 5 Secs";
FreqText[3].IText = (UBYTE *)" 10 Secs";
}
/*****************************************************************/
/* The following initializes the structure arrays */
/* needed to provide the Priority menu topic. */
/*****************************************************************/
void InitPrioItems()
{
int n,nplus1;
/* initialize each menu item and IntuiText with loop */
for( n=0; n<PRIOMAX; n++ )
{
nplus1 = n + 1;
PrioItem[n].NextItem = &PrioItem[nplus1];
PrioItem[n].LeftEdge = 0;
PrioItem[n].TopEdge = 9 * n;
PrioItem[n].Width = 80;
PrioItem[n].Height = 9;
PrioItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
PrioItem[n].MutualExclude = (~(1 << n));
if (n < 3) PrioItem[n].MutualExclude &= 0x0007;
if (n < 1) PrioItem[n].MutualExclude |= 0x0007;
PrioItem[n].ItemFill = (APTR)&PrioText[n];
PrioItem[n].SelectFill = NULL;
PrioItem[n].Command = 0;
PrioItem[n].NextSelect = 0;
PrioText[n].FrontPen = BLUP;
PrioText[n].BackPen = WHTP;
if (n > 11) {
PrioText[n].FrontPen = ORNP;
PrioText[n].BackPen = REDP;
}
PrioText[n].DrawMode = JAM2;
PrioText[n].LeftEdge = 0;
PrioText[n].TopEdge = 1;
PrioText[n].ITextFont = NULL;
PrioText[n].NextText = NULL;
}
PrioItem[PRIOMAX-1].NextItem = NULL;
/* select priority item checked */
switch (p_priority) {
case -99: n = 3; break;
case -75: n = 4; break;
case -50: n = 5; break;
case -25: n = 6; break;
case -20: n = 7; break;
case -15: n = 8; break;
case -10: n = 9; break;
case -5: n = 10; break;
case 0: n = 11; break;
case 5: n = 12; break;
case 10: n = 13; break;
case 15: n = 14; break;
case 20: n = 15; break;
default: n = 11; p_priority = 0;
}
PrioItem[n].Flags |= CHECKED;
PrioText[ 0].IText = (UBYTE *)" NORM ";
PrioText[ 1].IText = (UBYTE *)" DECR ";
PrioText[ 2].IText = (UBYTE *)" INCR ";
PrioText[ 3].IText = (UBYTE *)" -99 ";
PrioText[ 4].IText = (UBYTE *)" -75 ";
PrioText[ 5].IText = (UBYTE *)" -50 ";
PrioText[ 6].IText = (UBYTE *)" -25 ";
PrioText[ 7].IText = (UBYTE *)" -20 ";
PrioText[ 8].IText = (UBYTE *)" -15 ";
PrioText[ 9].IText = (UBYTE *)" -10 ";
PrioText[10].IText = (UBYTE *)" -5 ";
PrioText[11].IText = (UBYTE *)" 0 ";
PrioText[12].IText = (UBYTE *)" 5 ";
PrioText[13].IText = (UBYTE *)" 10 ";
PrioText[14].IText = (UBYTE *)" 15 ";
PrioText[15].IText = (UBYTE *)" 20 ";
}
/*****************************************************************/
/* The following initializes the structure arrays */
/* needed to provide the Chip Mem Size menu topic. */
/*****************************************************************/
void InitChipItems()
{
int n,nplus1;
/* initialize each menu item and IntuiText with loop */
for( n=0; n<CHIPMAX; n++ )
{
nplus1 = n + 1;
ChipItem[n].NextItem = &ChipItem[nplus1];
ChipItem[n].LeftEdge = 0;
ChipItem[n].TopEdge = 9 * n;
ChipItem[n].Width = 80;
ChipItem[n].Height = 9;
ChipItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
ChipItem[n].MutualExclude = (~(1 << n));
ChipItem[n].ItemFill = (APTR)&ChipText[n];
ChipItem[n].SelectFill = NULL;
ChipItem[n].Command = 0;
ChipItem[n].NextSelect = 0;
ChipText[n].FrontPen = BLUP;
ChipText[n].BackPen = WHTP;
ChipText[n].DrawMode = JAM2;
ChipText[n].LeftEdge = 0;
ChipText[n].TopEdge = 1;
ChipText[n].ITextFont = NULL;
ChipText[n].NextText = NULL;
}
ChipItem[CHIPMAX-1].NextItem = NULL;
/* select chip mem size item checked */
switch (p_chip) {
case 0: n = 0; break;
case 256: n = 1; break;
case 512: n = 2; break;
case 1024: n = 3; break;
case 2048: n = 4; break;
default: n = 2; p_chip = 512;
}
ChipItem[n].Flags |= CHECKED;
ChipText[0].IText = (UBYTE *)" NONE";
ChipText[1].IText = (UBYTE *)" 256K";
ChipText[2].IText = (UBYTE *)" 512K";
ChipText[3].IText = (UBYTE *)" 1 MB";
ChipText[4].IText = (UBYTE *)" 2 MB";
}
/*****************************************************************/
/* The following initializes the structure arrays */
/* needed to provide the Chip Base Addr menu topic. */
/*****************************************************************/
void InitChipAItems()
{
int n,nplus1;
/* initialize each menu item and IntuiText with loop */
for( n=0; n<CHIPAMAX; n++ )
{
nplus1 = n + 1;
ChipAItem[n].NextItem = &ChipAItem[nplus1];
ChipAItem[n].LeftEdge = 0;
ChipAItem[n].TopEdge = 9 * n;
ChipAItem[n].Width = 80;
ChipAItem[n].Height = 9;
ChipAItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
ChipAItem[n].MutualExclude = (~(1 << n));
ChipAItem[n].ItemFill = (APTR)&ChipAText[n];
ChipAItem[n].SelectFill = NULL;
ChipAItem[n].Command = 0;
ChipAItem[n].NextSelect = 0;
ChipAText[n].FrontPen = BLUP;
ChipAText[n].BackPen = WHTP;
ChipAText[n].DrawMode = JAM2;
ChipAText[n].LeftEdge = 0;
ChipAText[n].TopEdge = 1;
ChipAText[n].ITextFont = NULL;
ChipAText[n].NextText = NULL;
}
ChipAItem[CHIPAMAX-1].NextItem = NULL;
/* select chip base address item checked */
switch (p_chipa) {
case 0: n = 0; break;
case 256: n = 1; break;
case 512: n = 2; break;
case 1024: n = 3; break;
default: n = 0; p_chipa = 0;
}
ChipAItem[n].Flags |= CHECKED;
ChipAText[0].IText = (UBYTE *)" @ 0K";
ChipAText[1].IText = (UBYTE *)" @ 256K";
ChipAText[2].IText = (UBYTE *)" @ 512K";
ChipAText[3].IText = (UBYTE *)" @ 1 MB";
}
/*****************************************************************/
/* The following initializes the structure arrays */
/* needed to provide the Slow Fast Mem Size menu topic. */
/*****************************************************************/
void InitSFItems()
{
int n,nplus1;
/* initialize each menu item and IntuiText with loop */
for( n=0; n<SFMAX; n++ )
{
nplus1 = n + 1;
SFItem[n].NextItem = &SFItem[nplus1];
SFItem[n].LeftEdge = 0;
SFItem[n].TopEdge = 9 * n;
SFItem[n].Width = 80;
SFItem[n].Height = 9;
SFItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
SFItem[n].MutualExclude = (~(1 << n));
SFItem[n].ItemFill = (APTR)&SFText[n];
SFItem[n].SelectFill = NULL;
SFItem[n].Command = 0;
SFItem[n].NextSelect = 0;
SFText[n].FrontPen = BLUP;
SFText[n].BackPen = WHTP;
SFText[n].DrawMode = JAM2;
SFText[n].LeftEdge = 0;
SFText[n].TopEdge = 1;
SFText[n].ITextFont = NULL;
SFText[n].NextText = NULL;
}
SFItem[SFMAX-1].NextItem = NULL;
/* select slow fast mem size item checked */
switch (p_sf) {
case 0: n = 0; break;
case 512: n = 1; break;
case 1024: n = 2; break;
case 1536: n = 3; break;
default: n = 0; p_sf = 0;
}
SFItem[n].Flags |= CHECKED;
SFText[0].IText = (UBYTE *)" NONE ";
SFText[1].IText = (UBYTE *)" 0.5 MB";
SFText[2].IText = (UBYTE *)" 1 MB";
SFText[3].IText = (UBYTE *)" 1.5 MB";
}
/*****************************************************************/
/* The following initializes the structure arrays */
/* needed to provide the Slow Fast Mem Base Addr menu topic. */
/*****************************************************************/
void InitSFAItems()
{
int n,nplus1;
/* initialize each menu item and IntuiText with loop */
for( n=0; n<SFAMAX; n++ )
{
nplus1 = n + 1;
SFAItem[n].NextItem = &SFAItem[nplus1];
SFAItem[n].LeftEdge = 0;
SFAItem[n].TopEdge = 9 * n;
SFAItem[n].Width = 104;
SFAItem[n].Height = 9;
SFAItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
SFAItem[n].MutualExclude = (~(1 << n));
SFAItem[n].ItemFill = (APTR)&SFAText[n];
SFAItem[n].SelectFill = NULL;
SFAItem[n].Command = 0;
SFAItem[n].NextSelect = 0;
SFAText[n].FrontPen = BLUP;
SFAText[n].BackPen = WHTP;
SFAText[n].DrawMode = JAM2;
SFAText[n].LeftEdge = 0;
SFAText[n].TopEdge = 1;
SFAText[n].ITextFont = NULL;
SFAText[n].NextText = NULL;
}
SFAItem[SFAMAX-1].NextItem = NULL;
/* select slow fast mem base address item checked */
switch (p_sfa) {
case 12288: n = 0; break; /* 0x3000 kb = 12 mb */
case 12800: n = 1; break; /* 0x3200 kb = 12.5 mb */
case 13312: n = 2; break; /* 0x3400 kb = 13 mb */
case 13824: n = 3; break; /* 0x3600 kb = 13.5 mb */
default: n = 0; p_sfa = 12288;
}
SFAItem[n].Flags |= CHECKED;
SFAText[0].IText = (UBYTE *)" @ C.0 Meg";
SFAText[1].IText = (UBYTE *)" @ C.8 Meg";
SFAText[2].IText = (UBYTE *)" @ D.0 Meg";
SFAText[3].IText = (UBYTE *)" @ D.8 Meg";
}
/*****************************************************************/
/* The following initializes the structure arrays */
/* needed to provide the Fast Mem Size menu topic. */
/*****************************************************************/
void InitFastItems()
{
int n,nplus1;
/* initialize each menu item and IntuiText with loop */
for( n=0; n<FASTMAX; n++ )
{
nplus1 = n + 1;
FastItem[n].NextItem = &FastItem[nplus1];
FastItem[n].LeftEdge = 0;
FastItem[n].TopEdge = 9 * n;
FastItem[n].Width = 80;
FastItem[n].Height = 9;
FastItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
FastItem[n].MutualExclude = (~(1 << n));
FastItem[n].ItemFill = (APTR)&FastText[n];
FastItem[n].SelectFill = NULL;
FastItem[n].Command = 0;
FastItem[n].NextSelect = 0;
FastText[n].FrontPen = BLUP;
FastText[n].BackPen = WHTP;
FastText[n].DrawMode = JAM2;
FastText[n].LeftEdge = 0;
FastText[n].TopEdge = 1;
FastText[n].ITextFont = NULL;
FastText[n].NextText = NULL;
}
FastItem[FASTMAX-1].NextItem = NULL;
/* select fast mem size item checked */
switch (p_fast) {
case 0: n = 0; break;
case 512: n = 1; break;
case 1: n = 2; break;
case 2: n = 3; break;
case 4: n = 4; break;
case 6: n = 5; break;
case 8: n = 6; break;
default: n = 0; p_fast = 0;
}
FastItem[n].Flags |= CHECKED;
FastText[0].IText = (UBYTE *)" NONE";
FastText[1].IText = (UBYTE *)" 512K";
FastText[2].IText = (UBYTE *)" 1 MB";
FastText[3].IText = (UBYTE *)" 2 MB";
FastText[4].IText = (UBYTE *)" 4 MB";
FastText[5].IText = (UBYTE *)" 6 MB";
FastText[6].IText = (UBYTE *)" 8 MB";
}
/*****************************************************************/
/* The following initializes the structure arrays */
/* needed to provide the Fast Mem Base Addr menu topic. */
/*****************************************************************/
void InitFastAItems()
{
int n,nplus1;
/* initialize each menu item and IntuiText with loop */
for( n=0; n<FASTAMAX; n++ )
{
nplus1 = n + 1;
FastAItem[n].NextItem = &FastAItem[nplus1];
FastAItem[n].LeftEdge = 0;
FastAItem[n].TopEdge = 9 * n;
FastAItem[n].Width = 80;
FastAItem[n].Height = 9;
FastAItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
FastAItem[n].MutualExclude = (~(1 << n));
FastAItem[n].ItemFill = (APTR)&FastAText[n];
FastAItem[n].SelectFill = NULL;
FastAItem[n].Command = 0;
FastAItem[n].NextSelect = 0;
FastAText[n].FrontPen = BLUP;
FastAText[n].BackPen = WHTP;
FastAText[n].DrawMode = JAM2;
FastAText[n].LeftEdge = 0;
FastAText[n].TopEdge = 1;
FastAText[n].ITextFont = NULL;
FastAText[n].NextText = NULL;
}
FastAItem[FASTAMAX-1].NextItem = NULL;
/* select fast base address item checked */
switch (p_fasta) {
case 2: n = 0; break;
case 3: n = 1; break;
case 4: n = 2; break;
case 5: n = 3; break;
case 6: n = 4; break;
case 7: n = 5; break;
case 8: n = 6; break;
case 9: n = 7; break;
default: n = 0; p_fasta = 2;
}
FastAItem[n].Flags |= CHECKED;
FastAText[0].IText = (UBYTE *)" @ 2 M";
FastAText[1].IText = (UBYTE *)" @ 3 M";
FastAText[2].IText = (UBYTE *)" @ 4 M";
FastAText[3].IText = (UBYTE *)" @ 5 M";
FastAText[4].IText = (UBYTE *)" @ 6 M";
FastAText[5].IText = (UBYTE *)" @ 7 M";
FastAText[6].IText = (UBYTE *)" @ 8 M";
FastAText[7].IText = (UBYTE *)" @ 9 M";
}
/****************************************************************/
/* The following function inits the Menu structure array with */
/* appropriate values for our simple menu. Review the manual */
/* if you need to know what each value means. */
/****************************************************************/
void InitMenu()
{
menu[0].NextMenu = &menu[1];
menu[0].LeftEdge = 0;
menu[0].TopEdge = 0;
menu[0].Width = 64;
menu[0].Height = 10;
menu[0].Flags = MENUENABLED;
menu[0].MenuName = "Project"; /* text for menu-bar display */
menu[0].FirstItem = &ProjItem[0]; /* pointer to first item in list */
menu[1].NextMenu = &menu[2];
menu[1].LeftEdge = 64;
menu[1].TopEdge = 0;
menu[1].Width = 48;
menu[1].Height = 10;
menu[1].Flags = MENUENABLED;
menu[1].MenuName = "Setup"; /* text for menu-bar display */
menu[1].FirstItem = &SetupItem[0]; /* pointer to first item in list */
menu[2].NextMenu = &menu[3];
menu[2].LeftEdge = 112;
menu[2].TopEdge = 0;
menu[2].Width = 72;
menu[2].Height = 10;
menu[2].Flags = MENUENABLED;
menu[2].MenuName = "Priority"; /* text for menu-bar display */
menu[2].FirstItem = &PrioItem[0]; /* pointer to first item in list */
menu[3].NextMenu = &menu[4];
menu[3].LeftEdge = 184;
menu[3].TopEdge = 0;
menu[3].Width = 80;
menu[3].Height = 10;
menu[3].Flags = MENUENABLED;
menu[3].MenuName = "Chip Size"; /* text for menu-bar display */
menu[3].FirstItem = &ChipItem[0]; /* pointer to first item in list */
menu[4].NextMenu = &menu[5];
menu[4].LeftEdge = 264;
menu[4].TopEdge = 0;
menu[4].Width = 80;
menu[4].Height = 10;
menu[4].Flags = MENUENABLED;
menu[4].MenuName = "Chip Addr"; /* text for menu-bar display */
menu[4].FirstItem = &ChipAItem[0]; /* pointer to first item in list */
menu[5].NextMenu = &menu[6];
menu[5].LeftEdge = 344;
menu[5].TopEdge = 0;
menu[5].Width = 64;
menu[5].Height = 10;
menu[5].Flags = MENUENABLED;
menu[5].MenuName = "SF Size"; /* text for menu-bar display */
menu[5].FirstItem = &SFItem[0]; /* pointer to first item in list */
menu[6].NextMenu = &menu[7];
menu[6].LeftEdge = 408;
menu[6].TopEdge = 0;
menu[6].Width = 64;
menu[6].Height = 10;
menu[6].Flags = MENUENABLED;
menu[6].MenuName = "SF Addr"; /* text for menu-bar display */
menu[6].FirstItem = &SFAItem[0]; /* pointer to first item in list */
menu[7].NextMenu = &menu[8];
menu[7].LeftEdge = 472;
menu[7].TopEdge = 0;
menu[7].Width = 80;
menu[7].Height = 10;
menu[7].Flags = MENUENABLED;
menu[7].MenuName = "Fast Size"; /* text for menu-bar display */
menu[7].FirstItem = &FastItem[0]; /* pointer to first item in list */
menu[8].NextMenu = NULL;
menu[8].LeftEdge = 552;
menu[8].TopEdge = 0;
menu[8].Width = 80;
menu[8].Height = 10;
menu[8].Flags = MENUENABLED;
menu[8].MenuName = "Fast Addr"; /* text for menu-bar display */
menu[8].FirstItem = &FastAItem[0]; /* pointer to first item in list */
}
void StartMenus()
{
SetMenuStrip(window,&menu[0]);
}